{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Nonlinearity Analysis with NHANES Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import loadnhanes\n",
    "import sklearn\n",
    "import numpy as np\n",
    "import shap\n",
    "import pandas as pd\n",
    "import xgboost as xgb\n",
    "from matplotlib import pyplot as plt\n",
    "from tqdm import tqdm\n",
    "from sklearn.metrics import mean_squared_error as mse, r2_score as r2, roc_auc_score as auc\n",
    "from sklearn.linear_model import LogisticRegressionCV, LassoCV\n",
    "from scipy.special import expit, logit\n",
    "from collections import defaultdict\n",
    "import mpld3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "VAL_SEED = 27\n",
    "TEST_SEED = 12\n",
    "\n",
    "NP_SEED = 10\n",
    "XG_SEED=20\n",
    "np.random.seed(NP_SEED)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Binary cross-entropy for scoring models\n",
    "def bce(truth,preds):\n",
    "    return np.mean(-truth*np.log(preds)-(1-truth)*np.log(1-preds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statsmodels.api as sm\n",
    "import statsmodels.genmod.generalized_linear_model as sm_glm\n",
    "\n",
    "# Range of regularization strengths\n",
    "ALPHAS = [0.0]\n",
    "\n",
    "# # Uncomment to use a regularized model and do a parameter search\n",
    "# ALPHAS = np.logspace(-10,4,15)\n",
    "\n",
    "# StatsModels logistic regression\n",
    "# family is statsmodels family to fit as link function\n",
    "# score is metric to optimize; must be positive\n",
    "class SmGlm(object):\n",
    "    def __init__(self,family=sm.families.Binomial(),score=r2):\n",
    "        self.family = family\n",
    "        self.fit_results = []\n",
    "        self.fit_scores = []\n",
    "        self.best_ind = None\n",
    "        self.score = score\n",
    "        \n",
    "    def fit(self, X, y):\n",
    "        # Handle Pandas\n",
    "        if str(type(X)).endswith(\"'pandas.core.frame.DataFrame'>\"):\n",
    "            X = X.values\n",
    "        # Append bias term\n",
    "        X=np.hstack((X,np.ones(X.shape[0]).reshape(-1,1)))\n",
    "        \n",
    "        # Split for model tuning; all validation splits are the same throughout this code\n",
    "        Xtt,Xtv,ytt,ytv = sklearn.model_selection.train_test_split(\n",
    "            X, y, test_size=0.2, random_state=VAL_SEED)        \n",
    "        \n",
    "        # Tune regularizaton parameter\n",
    "        for alpha in ALPHAS:\n",
    "            # Instantiate GLM\n",
    "            model_class = sm_glm.GLM(ytt,Xtt,family=self.family)\n",
    "            \n",
    "            model = model_class.fit_regularized(alpha=alpha)\n",
    "            self.fit_results.append(model)\n",
    "            preds = model.predict(Xtv)\n",
    "            self.fit_scores.append(self.score(ytv,preds))\n",
    "        self.best_ind = np.argmax(self.fit_scores)\n",
    "        \n",
    "    def predict(self, X):\n",
    "        # Handle Pandas\n",
    "        if str(type(X)).endswith(\"'pandas.core.frame.DataFrame'>\"):\n",
    "            X = X.values\n",
    "            \n",
    "        # Append bias term\n",
    "        X=np.hstack((X,np.ones(X.shape[0]).reshape(-1,1)))\n",
    "        \n",
    "        # Predict\n",
    "        return self.fit_results[self.best_ind].predict(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load data\n",
    "X = pd.read_csv(\"data/X_orig.csv\",index_col=0)\n",
    "y = np.load(\"data/y_orig.npy\")\n",
    "\n",
    "# Preprocess BMI\n",
    "# Silly trick, each of the height values in denominator should be divided by 100 to get meters\n",
    "# so instead we multiply result by 10,000\n",
    "X[\"bmi\"] = 10000 * X[\"weight\"].values.copy() / (X[\"height\"].values.copy() * X[\"height\"].values.copy())\n",
    "del X[\"weight\"]\n",
    "del X['height']\n",
    "bottom, top = X.quantile(0.01),X.quantile(0.99)\n",
    "X_orig = X\n",
    "X = X.clip(lower=bottom,upper=top,axis=1)\n",
    "# Winsorize\n",
    "bottom, top = X.quantile(0.01),X.quantile(0.99)\n",
    "X_orig = X\n",
    "X = X.clip(lower=bottom,upper=top,axis=1)\n",
    "\n",
    "# Train test split\n",
    "Xtrain, Xtest, ytrain, ytest = sklearn.model_selection.train_test_split(\n",
    "        X, y, test_size=0.2, random_state=TEST_SEED)\n",
    "Xtraintrain, Xtrainvalid, ytraintrain, ytrainvalid = sklearn.model_selection.train_test_split(\n",
    "        Xtrain, ytrain, test_size=0.2, random_state=VAL_SEED)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Scale data\n",
    "mu = Xtrain.mean()\n",
    "sigma = Xtrain.var()**0.5\n",
    "\n",
    "X -= mu\n",
    "Xtrain -= mu\n",
    "Xtraintrain -= mu\n",
    "Xtrainvalid -= mu\n",
    "Xtest -= mu\n",
    "for col in sigma.index:\n",
    "    if sigma[col] != 0:\n",
    "        X[col] /= sigma[col]\n",
    "        Xtrain[col] /= sigma[col]\n",
    "        Xtraintrain[col] /= sigma[col]\n",
    "        Xtrainvalid[col] /= sigma[col]\n",
    "        Xtest[col] /= sigma[col]\n",
    "\n",
    "# Impute mean\n",
    "X.fillna(0, inplace=True)\n",
    "Xtrain.fillna(0, inplace=True)\n",
    "Xtraintrain.fillna(0, inplace=True)\n",
    "Xtrainvalid.fillna(0, inplace=True)\n",
    "Xtest.fillna(0, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Synthetic Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters for true model and learner\n",
    "scorefunc = lambda x,y: -bce(x,y) #-mse(x,y)\n",
    "xgscore = 'logloss' # 'auc'\n",
    "xgobjective = 'binary:logistic' #'reg:linear'\n",
    "linkfunc = lambda x: expit(x)\n",
    "probfunc = lambda x: x\n",
    "regressor = lambda: SmGlm(score=scorefunc) \n",
    "predfunc = lambda model,x: model.predict(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Polynomial coefficients to generate linear labels within a given range\n",
    "def lin_min_max(mn,mx,bottom,top):\n",
    "    m = float(top-bottom)/(mx-mn)\n",
    "    b = bottom-mn*m\n",
    "    return np.array([m,b])\n",
    "\n",
    "# Polynomial coefficients to generate quadratic labels with a given x,y range and center\n",
    "def quad_min_max_ctr(mn,mx,ctr,bottom,top):\n",
    "    farthest_x = max(np.abs(mx-ctr),np.abs(mn-ctr))\n",
    "    scale = float(top-bottom)/(farthest_x**2)\n",
    "    return np.array([scale,-2*scale*ctr,scale*ctr**2+bottom])\n",
    "\n",
    "# Evaluate polynomial given coefficients\n",
    "def poly(x,coefs):\n",
    "    y = np.zeros_like(x)\n",
    "    for i,v in enumerate(coefs[::-1]):\n",
    "        y += x**i*v\n",
    "    return y\n",
    "\n",
    "# Higher-level \"generate y\" function\n",
    "def gen_y(primary_x,x,p,noise=False):\n",
    "    return linkfunc(poly(primary_x,lin_primary)+p*poly(x,quad)+(1-p)*poly(x,lin)+\n",
    "                 (np.random.random(size=x.shape[0])*noise_scale-noise_scale/2.0)*int(noise))\n",
    "\n",
    "# Contribs for \"generate y\" -- don't add noise, remove the link and don't sum the contributions\n",
    "def gen_y_contribs(primary_x,x,p,noise=False):\n",
    "    return poly(primary_x,lin_primary), p*poly(x,quad)+(1-p)*poly(x,lin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define ranges and polynomials for synthetic data\n",
    "bottomy, topy = -1.0,1.0\n",
    "primary_bottomy, primary_topy = -2.0,2.0\n",
    "feat = 'bmi'\n",
    "primary = 'age'\n",
    "prim_ind = Xtrain.columns.get_loc(primary)\n",
    "feat_ind = Xtrain.columns.get_loc(feat)\n",
    "mn,mx  = np.min(Xtrain[feat].dropna()),np.max(Xtrain[feat].dropna())\n",
    "primary_mn, primary_mx = np.min(Xtrain[primary].dropna()),np.max(Xtrain[primary].dropna())\n",
    "xr = np.linspace(mn,mx)\n",
    "primary_xr = np.linspace(primary_mn,primary_mx)\n",
    "lin_primary = lin_min_max(primary_mn,primary_mx,primary_bottomy,primary_topy)\n",
    "lin = lin_min_max(mn,mx,bottomy,topy)\n",
    "sharp = quad_min_max_ctr(mn,mx,np.mean(Xtrain[feat].dropna()),bottomy,topy)\n",
    "\n",
    "quad = sharp\n",
    "ys = []\n",
    "ys_test = []\n",
    "thresholds = np.random.random(size=Xtrain[feat].shape[0])\n",
    "thresholds_test = np.random.random(size=Xtest[feat].shape[0])\n",
    "noise_scale = np.abs(topy-bottomy)/5\n",
    "\n",
    "# Generate datasets of varying nonlinearity (0 to 1)\n",
    "for i in range(11):\n",
    "    p = i*0.1\n",
    "    y_range = gen_y(primary_xr,xr,p)\n",
    "    y_data = gen_y(Xtrain[primary],Xtrain[feat],p)\n",
    "    y_data_test = gen_y(Xtest[primary],Xtest[feat],p)\n",
    "    ys.append(y_data)\n",
    "    ys_test.append(y_data_test)\n",
    "ys_probs = np.array(ys)\n",
    "ys_test_probs = np.array(ys_test)\n",
    "ys = probfunc(ys_probs)\n",
    "ys_test = probfunc(ys_test_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train and Explain Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "###############\n",
    "# Train Models\n",
    "###############\n",
    "\n",
    "# Store results for each nonlinearity level\n",
    "fresults = []\n",
    "\n",
    "# Use 7500 data points\n",
    "n = 7500\n",
    "\n",
    "# Iterate through nonlinearity levels (ys and ys_test range in nonlinearity from 0 to 1)\n",
    "for ytrain_synth, ytest_synth in tqdm(zip(ys,ys_test),total=len(ys)):\n",
    "    \n",
    "    # Get our usual validation split\n",
    "    Xtt, Xtv, ytt, ytv = sklearn.model_selection.train_test_split(\n",
    "        Xtrain.iloc[:n], ytrain_synth[:n], test_size=0.2, random_state=VAL_SEED)\n",
    "    \n",
    "    # Build full-feature XGBoost model\n",
    "    # Data\n",
    "    dtrain = xgb.DMatrix(Xtt,label=ytt)\n",
    "    dvalid = xgb.DMatrix(Xtv,label=ytv)\n",
    "    dtest = xgb.DMatrix(Xtest,label=ytest_synth)\n",
    "    # Parameters to search\n",
    "    xgb_param_grid = {\n",
    "        \"eta\": [0.01], #[0.001,0.01,0.1],\n",
    "        \"max_depth\":[1,2,4,8,10],\n",
    "        \"gamma\": [1.0], #[0.1,1.0,10.0],\n",
    "        \"min_child_weight\": [10], #[1,10,100],full_tshaps[k][i]\n",
    "        \"subsample\":[0.2,0.5,0.8,1.0],\n",
    "        \"base_score\":[np.mean(ytt)],\n",
    "        \"objective\":[xgobjective],\n",
    "        #\"n_estimators\":[10,100,1000],\n",
    "        \"eval_metric\":[xgscore],\n",
    "        \"tree_method\":[\"approx\"],\n",
    "        \"silent\":[1],\n",
    "        'seed':[XG_SEED]\n",
    "    }\n",
    "    # Loop over parameters and find best estimator\n",
    "    xg_bestimator = None\n",
    "    xg_best_score = -float('inf')\n",
    "    xg_params_scores = {}\n",
    "    xg_results = {}\n",
    "    xg_keys = xgb_param_grid.keys()\n",
    "    for vals in itertools.product(*[xgb_param_grid[k] for k in xg_keys]):\n",
    "        pd = {k:v for k,v in zip(xg_keys,vals)}\n",
    "        xg_results[vals]={}\n",
    "        bst = xgb.train(pd,dtrain,1000,([dvalid,\"valid\"],),verbose_eval=False,evals_result=xg_results[vals],early_stopping_rounds=10)\n",
    "\n",
    "        cur_score = scorefunc(ytv,bst.predict(dvalid))\n",
    "        xg_params_scores[vals]=cur_score\n",
    "        if cur_score>xg_best_score:\n",
    "            xg_bestimator = bst\n",
    "            xg_best_score = cur_score\n",
    "    # Predictions\n",
    "    xg_tpreds = xg_bestimator.predict(dtrain)\n",
    "    xg_vpreds = xg_bestimator.predict(dvalid)\n",
    "    xg_testpreds = xg_bestimator.predict(dtest)\n",
    "    # XGBoost shap values\n",
    "    xg_tshap = np.sum(np.abs(xg_bestimator.predict(dtrain,pred_contribs=1)),axis=0)[:-1]\n",
    "    xg_vshap = np.sum(np.abs(xg_bestimator.predict(dvalid,pred_contribs=1)),axis=0)[:-1]\n",
    "    xg_testshap = np.sum(np.abs(xg_bestimator.predict(dtest,pred_contribs=1)),axis=0)[:-1]\n",
    "\n",
    "    # Build 2-feature XGBoost model\n",
    "    # Data\n",
    "    dtrain2 = xgb.DMatrix(Xtt.loc[:,[primary,feat]],label=ytt)\n",
    "    dvalid2 = xgb.DMatrix(Xtv.loc[:,[primary,feat]],label=ytv)\n",
    "    dtest2 = xgb.DMatrix(Xtest.loc[:,[primary,feat]],label=ytest_synth)\n",
    "    # Loop over parameters and find best estimator\n",
    "    xg_bestimator2 = None\n",
    "    xg_best_score2 = -float('inf')\n",
    "    xg_params_scores2 = {}\n",
    "    xg_results2 = {}\n",
    "    for vals in itertools.product(*[xgb_param_grid[k] for k in xg_keys]):\n",
    "        pd = {k:v for k,v in zip(xg_keys,vals)}\n",
    "        xg_results2[vals]={}\n",
    "        bst = xgb.train(pd,dtrain2,1000,([dvalid2,\"valid\"],),verbose_eval=False,evals_result=xg_results2[vals],early_stopping_rounds=10)\n",
    "\n",
    "        cur_score = scorefunc(ytv,bst.predict(dvalid2))\n",
    "        xg_params_scores2[vals]=cur_score\n",
    "        if cur_score>xg_best_score2:\n",
    "            xg_bestimator2 = bst\n",
    "            xg_best_score2 = cur_score\n",
    "    # Predictions\n",
    "    xg_tpreds2 = xg_bestimator2.predict(dtrain2)\n",
    "    xg_vpreds2 = xg_bestimator2.predict(dvalid2)\n",
    "    xg_testpreds2 = xg_bestimator2.predict(dtest2)\n",
    "    # XGBoost shap values\n",
    "    xg_tshap2 = np.sum(np.abs(xg_bestimator2.predict(dtrain2,pred_contribs=1)),axis=0)[:-1]\n",
    "    xg_vshap2 = np.sum(np.abs(xg_bestimator2.predict(dvalid2,pred_contribs=1)),axis=0)[:-1]\n",
    "    xg_testshap2 = np.sum(np.abs(xg_bestimator2.predict(dtest2,pred_contribs=1)),axis=0)[:-1]\n",
    "    \n",
    "    # Build all-feature linear model\n",
    "    lr = regressor()\n",
    "    lr.fit(Xtrain.iloc[:n], ytrain_synth[:n])\n",
    "    # Predictions\n",
    "    lr_tpreds = predfunc(lr,Xtt) #lr.predict_proba(Xtt)[:,1]\n",
    "    lr_vpreds = predfunc(lr,Xtv) #lr.predict_proba(Xtv)[:,1]\n",
    "    lr_testpreds = predfunc(lr,Xtest) #lr.predict_proba(Xtest[rand_feats[:k_ind]])[:,1]\n",
    "    # Linear shap\n",
    "    coefs = lr.fit_results[lr.best_ind].params\n",
    "    lr_tcoef = np.sum(np.abs(coefs[:-1]*Xtt),axis=0)\n",
    "    lr_vcoef = np.sum(np.abs(coefs[:-1]*Xtv),axis=0)\n",
    "    lr_testcoef = np.sum(np.abs(coefs[:-1]*Xtest),axis=0)\n",
    "    \n",
    "    # Build 2-feature linear model\n",
    "    lr2 = regressor()\n",
    "    lr2.fit(Xtrain.iloc[:n].loc[:,[primary,feat]], ytrain_synth[:n])\n",
    "    # Predictions\n",
    "    lr_tpreds2 = predfunc(lr2,Xtt.loc[:,[primary,feat]]) #lr.predict_proba(Xtt)[:,1]\n",
    "    lr_vpreds2 = predfunc(lr2,Xtv.loc[:,[primary,feat]]) #lr.predict_proba(Xtv)[:,1]\n",
    "    lr_testpreds2 = predfunc(lr2,Xtest.loc[:,[primary,feat]]) #lr.predict_proba(Xtest[rand_feats[:k_ind]])[:,1]\n",
    "    # Linear shap\n",
    "    coefs2 = lr2.fit_results[lr2.best_ind].params\n",
    "    lr_tcoef2 = np.sum(np.abs(coefs2[:-1]*Xtt.loc[:,[primary,feat]]),axis=0)\n",
    "    lr_vcoef2 = np.sum(np.abs(coefs2[:-1]*Xtv.loc[:,[primary,feat]]),axis=0)\n",
    "    lr_testcoef2 = np.sum(np.abs(coefs2[:-1]*Xtest.loc[:,[primary,feat]]),axis=0)\n",
    "    \n",
    "    fresults.append({\n",
    "        'xg':xg_bestimator,\n",
    "        'xg_tpreds':xg_tpreds,\n",
    "        'xg_vpreds':xg_vpreds,\n",
    "        'xg_testpreds':xg_testpreds,\n",
    "        'xg_tshap':xg_tshap,\n",
    "        'xg_vshap':xg_vshap,\n",
    "        'xg2':xg_bestimator2,\n",
    "        'xg_tpreds2':xg_tpreds2,\n",
    "        'xg_vpreds2':xg_vpreds2,\n",
    "        'xg_testpreds2':xg_testpreds2,\n",
    "        'xg_tshap2':xg_tshap2,\n",
    "        'xg_vshap2':xg_vshap2,\n",
    "        'lr':lr,\n",
    "        'lr_tpreds':lr_tpreds,\n",
    "        'lr_vpreds':lr_vpreds,\n",
    "        'lr_testpreds':lr_testpreds,\n",
    "        'lr_tcoef':lr_tcoef,\n",
    "        'lr_vcoef':lr_vcoef,\n",
    "        'lr_testcoef':lr_testcoef,\n",
    "        'lr2':lr2,\n",
    "        'lr_tpreds2':lr_tpreds2,\n",
    "        'lr_vpreds2':lr_vpreds2,\n",
    "        'lr_testpreds2':lr_testpreds2,\n",
    "        'lr_tcoef2':lr_tcoef2,\n",
    "        'lr_vcoef2':lr_vcoef2,\n",
    "        'lr_testcoef2':lr_testcoef2\n",
    "    })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fraction of importance on primary, secondary, and other features\n",
    "prange = np.linspace(0,1,11)\n",
    "frac_imp = defaultdict(list)\n",
    "for i,p in enumerate(prange): #range(len(fresults)):\n",
    "    xgvals = fresults[i]['xg_tshap']/fresults[i]['xg_tshap'].sum()\n",
    "    lrvals = fresults[i]['lr_tcoef']/fresults[i]['lr_tcoef'].sum()\n",
    "    true_contribs = np.sum(np.abs(np.vstack(gen_y_contribs(Xtrain[primary],Xtrain[feat],p)).T),axis=0)\n",
    "    true_contribs /= np.sum(true_contribs)\n",
    "    frac_imp['true_primary'].append(true_contribs[0])\n",
    "    frac_imp['true_feat'].append(true_contribs[1])\n",
    "    frac_imp['true_other'].append(0)\n",
    "    frac_imp['xg_primary'].append(xgvals[prim_ind])\n",
    "    frac_imp['xg_feat'].append(xgvals[feat_ind])\n",
    "    frac_imp['xg_other'].append(1-xgvals[prim_ind]-xgvals[feat_ind])\n",
    "    frac_imp['lr_primary'].append(lrvals[prim_ind])\n",
    "    frac_imp['lr_feat'].append(lrvals[feat_ind])\n",
    "    frac_imp['lr_other'].append(1-lrvals[prim_ind]-lrvals[feat_ind])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Full SHAP matrices on train data for XG/LR/true models\n",
    "full_tshaps = {}\n",
    "full_tshaps['xg'] = [t['xg'].predict(dtrain,pred_contribs=1) for t in fresults]\n",
    "full_tshaps['xg2'] = [t['xg2'].predict(dtrain2,pred_contribs=1) for t in fresults]\n",
    "full_tshaps['lr'] = [t['lr'].fit_results[t['lr'].best_ind].params[:-1]*Xtt for t in fresults]\n",
    "full_tshaps['lr2'] = [t['lr2'].fit_results[t['lr2'].best_ind].params[:-1]*Xtt.loc[:,[primary,feat]] for t in fresults]\n",
    "full_tshaps['true'] = [np.vstack(gen_y_contribs(Xtt[primary],Xtt[feat],p)).T for p in prange]\n",
    "for i,p in enumerate(prange): full_tshaps['true'][i] -= np.mean(full_tshaps['true'][i],axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Result Figures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1500x225 with 7 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Main text figure - Plot the true data\n",
    "fig,axarr = plt.subplots(1,6,dpi=150,figsize=(10,1.5),sharey='all')\n",
    "for i in range(6):\n",
    "    p = i*0.2\n",
    "    xr_pair, primary_xr_pair = zip(*itertools.product(xr,primary_xr))\n",
    "    mgrid = np.array(gen_y(np.array(primary_xr_pair),np.array(xr_pair),p)).reshape(len(xr),len(primary_xr))\n",
    "    heatmap = axarr[i].pcolormesh((mgrid),cmap=shap.plots.colors.red_blue,vmin=0,vmax=1)\n",
    "#     axarr[i].set_title(\"%.1f Nonlinear\"%p)\n",
    "    axarr[i].xaxis.tick_top()\n",
    "    axarr[i].xaxis.set_label_position(\"top\")\n",
    "    axarr[i].set_xlabel(\"Age\")\n",
    "    axarr[i].set_xticklabels([f'{p*sigma[\"age\"]+mu[\"age\"]:.0f}' for p in primary_xr[[0,20,40]]])\n",
    "    axarr[i].contour(mgrid,levels=np.linspace(0,1,6),colors=\"white\",alpha=0.2)\n",
    "axarr[0].set_ylabel(\"BMI\")\n",
    "axarr[0].set_yticklabels([f'{p*sigma[\"bmi\"]+mu[\"bmi\"]:.0f}' for p in xr[[0,10,20,30,40]]])\n",
    "fig.colorbar(heatmap,ticks=np.linspace(0,1,6))\n",
    "plt.subplots_adjust(hspace=0.5)\n",
    "# plt.savefig(\"nonlinearity_data.pdf\",dpi=300,bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f6b9c047710>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1500x337.5 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Main text figure - Performance of models as nonlinearity increases\n",
    "plt.figure(dpi=150,figsize=(10,2.25))\n",
    "truth= np.array([-scorefunc(y,y) for r,y in zip(fresults,ys_test)])\n",
    "xgt= np.array([-scorefunc(y,r['xg_testpreds']) for r,y in zip(fresults,ys_test)])\n",
    "xgt2= np.array([-scorefunc(y,r['xg_testpreds2']) for r,y in zip(fresults,ys_test)])\n",
    "lrt= np.array([-scorefunc(y,r['lr_testpreds']) for r,y in zip(fresults,ys_test)])\n",
    "lrt2= np.array([-scorefunc(y,r['lr_testpreds2']) for r,y in zip(fresults,ys_test)])\n",
    "plt.plot(xgt-truth,label='All-feature gradient boosting',\n",
    "         color=shap.plots.colors.blue_rgb,linewidth=3)\n",
    "plt.plot(xgt2-truth,'--',label='Two-feature gradient boosting',\n",
    "         color=shap.plots.colors.blue_rgb,linewidth=3)\n",
    "plt.plot(lrt-truth,label='All-feature logistic regression',\n",
    "         color=shap.plots.colors.red_rgb,linewidth=3)\n",
    "plt.plot(lrt2-truth,'--',label='Two-feature logistic regression',\n",
    "         color=shap.plots.colors.red_rgb,linewidth=3)\n",
    "plt.plot(truth-truth,label='True model', \n",
    "         color=(shap.plots.colors.red_rgb+shap.plots.colors.blue_rgb)/2,linewidth=3)\n",
    "plt.xlabel(\"Percent Nonlinearity\")\n",
    "plt.xticks(np.arange(0,11,2),[0,0.2,0.4,0.6,0.8,1.0])\n",
    "plt.ylabel(\"Logloss - Logloss of true model\")\n",
    "plt.title(\"Performance of models as nonlinearity increases\")\n",
    "plt.legend()\n",
    "# plt.show()\n",
    "# plt.savefig(\"nonlinearity_performance_unreg.pdf\",dpi=300,bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Fraction feature weight assigned to irrelevant features')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1500x337.5 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Main text figure - Fraction feature weight assigned to irrelevant features\n",
    "\n",
    "plt.figure(dpi=150,figsize=(10,2.25))\n",
    "plt.plot(prange,frac_imp['xg_'+\"other\"],label='Gradient Boosting (XGBoost)',color=shap.plots.colors.blue_rgb,linewidth=3)\n",
    "plt.plot(prange,frac_imp['lr_'+\"other\"],label='Logistic Regression (StatsModels GLM)',color=shap.plots.colors.red_rgb,linewidth=3)\n",
    "# plt.plot(prange,frac_imp['true_'+\"other\"],label='True Contribution',\n",
    "#          color=(shap.plots.colors.red_rgb+shap.plots.colors.blue_rgb)/2,\n",
    "#          linewidth=3)\n",
    "# plt.legend()\n",
    "plt.xlabel(\"Nonlinearity of Weight-Label Relationship\")\n",
    "plt.ylabel(\"Fraction feature weight assigned\\nto irrelevant features\")\n",
    "plt.title(\"Fraction feature weight assigned to irrelevant features\")\n",
    "# plt.savefig(\"nonlinearity_irrelevant_unreg.pdf\",dpi=300,bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f6b77b93c18>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1500x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Supplementary Figure - Cancellation Effects\n",
    "\n",
    "plt.figure(dpi=150,figsize=(10,4))\n",
    "\n",
    "total_lr = np.array([np.sum(np.abs(t.values)) for t in full_tshaps['lr']])\n",
    "total_lr2 = np.array([np.sum(np.abs(t.values)) for t in full_tshaps['lr2']])\n",
    "\n",
    "margin_lr = np.array([np.sum(t.values) for t in full_tshaps['lr']])\n",
    "margin_lr2 = np.array([np.sum(t.values) for t in full_tshaps['lr2']])\n",
    "\n",
    "total_xg = np.array([np.sum(np.abs(t)) for t in full_tshaps['xg']])\n",
    "total_xg2 = np.array([np.sum(np.abs(t)) for t in full_tshaps['xg2']])\n",
    "\n",
    "margin_xg = np.array([np.sum(t) for t in full_tshaps['xg']])\n",
    "margin_xg2 = np.array([np.sum(t) for t in full_tshaps['xg2']])\n",
    "\n",
    "plt.plot(prange,margin_xg-margin_xg2,label='Gradient boosting - total attribution',color=shap.plots.colors.blue_rgb,linewidth=3,linestyle='--')\n",
    "plt.plot(prange,total_xg-total_xg2,label='Gradient boosting - total abs. attribution',color=shap.plots.colors.blue_rgb,linewidth=3)\n",
    "\n",
    "plt.plot(prange,margin_lr-margin_lr2,label='Logistic regression - total attribution',color=shap.plots.colors.red_rgb,linewidth=3,linestyle='--')\n",
    "plt.plot(prange,total_lr-total_lr2,label='Logistic regression - total abs. attribution',color=shap.plots.colors.red_rgb,linewidth=3)\n",
    "plt.xlabel(\"Nonlinearity\")\n",
    "plt.ylabel(\"Increase from 2-feature model\\nto all-feature model\")\n",
    "plt.legend()\n",
    "# plt.savefig(\"nonlinearity_supp_both_unreg.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
